home *** CD-ROM | disk | FTP | other *** search
/ Netware Super Library / Netware Super Library.iso / pgm_tool / lu62 / recwait.c < prev    next >
C/C++ Source or Header  |  1995-07-03  |  14KB  |  335 lines
  1. /*
  2.                      RECEIVE AND WAIT
  3.  
  4.   Function: This subroutine has deal with verbs receive_and_wait and
  5.             receive_immediate.
  6.             In case if resource associated with verb has been right defined
  7.             and conversation is in SEND state verb processing will be
  8.             proceeded.
  9.  
  10.             PS gets records from RM and HS. Actions which will be selected
  11.             depend on received record type. Selected action affects state
  12.             of FSM_ERROR_OR_FAILURE.
  13.  
  14.  Input: pointer to the structure receive_and_wait or receive_immediate
  15.  
  16.  CopyRight 1995. Nicholas Poljakov all rights reserved.
  17.  
  18.  */
  19.  
  20. #include <stdio.h>
  21. #include <recwait.h>
  22. #include <state1.h>
  23. #include <rcb.h>
  24. #include <tcb.h>
  25. #include <lucb.h>
  26. #include <cma.h>
  27. #include <psp.h>
  28. #include <scb.h>
  29. #include <drcb.h>
  30. #include <prefix.h>
  31. #include <partner.h>
  32. #include <repass.h>
  33. #include <string.h>
  34. #include <malloc.h>
  35.  
  36. extern struct lucb lu6;
  37. int sk_r_wt(void *);
  38. int SendBlock(void *, void *);
  39. int setrc(void *, void *);
  40. int sendhsf(void *);
  41. int sendhs(void *);
  42. int sendbm(void *, void *);
  43. int sendat(void *);
  44. int rtsend(void *);
  45. unsigned long rmfmh5(void *, void *);
  46. int rcvru(void *, void *);
  47. int rcvhs(void *, void *, void *, void *);
  48. int ralloc(void *, void *);
  49. int psrm(int, void *, void *);
  50. int ps_conv(int, void *);
  51. int proterr(void *, unsigned long);
  52. int preptrcv(void *, void *);
  53. int post_rcb(void *);
  54. struct repass *postopen(void *);
  55. int phsrec(void *);
  56. int pfmh5(void *);
  57. int opndst(void *);
  58. int obtsess(void *, unsigned char);
  59. int Lrf_handler(void *);
  60. int get_sess(void *, void *);
  61. int get_attr(void *);
  62. int fsm_error(unsigned char, void *);
  63. int fsm_conv(unsigned char, unsigned char, void *);
  64. int flush (void *);
  65. int dcp(void *);
  66. int dealloc(void *);
  67. int crtp(void *);
  68. int conv(void *);
  69. int chkparm(void *, void *);
  70. int check_end(unsigned int, void *);
  71. struct rqb *call_appl(void *);
  72. int buffmng(unsigned char, void *, void *, void *, unsigned, unsigned char, unsigned);
  73. unsigned long attltck(void *);
  74. unsigned long attacheck(void *);
  75. char *cgetmem(int, int);
  76. int sendhsf(void *);
  77. int opndst(void *);
  78. int alloc_rcb(void *, void *);
  79. int allocate(void *);
  80. int clsdst(void *);
  81.  
  82. int recwait(ptr)
  83. struct rcwait *ptr;
  84.  {
  85. struct rcb *ptr_rcb;
  86. struct tcb *ptr_tcb;
  87. struct psp *ptr_psp;
  88. struct repass *p_rep;
  89. struct scb *p_scb;
  90. struct cma ar;
  91. struct drcb del_rcb;
  92. struct pnlu *part;
  93. int  fsm_conv();
  94. int  fsm_err();
  95. int code;
  96. char r;
  97. char s;
  98. char *p;
  99. char *pl;
  100. char fill;
  101. char p1;
  102. int param;
  103. int length;
  104. unsigned int type;
  105. int cnt;
  106. int i;
  107. int state;
  108. unsigned char temp;
  109.  
  110. #if OS_TYPE == 1
  111. /*********  Trace facility **********/
  112. unsigned int rtype;   /* type of record */
  113. unsigned int pnum;    /* point number */
  114. char pname[8];        /* name of module */
  115. char *drec;       /* record for dump */
  116. int  lenr;            /* record length */
  117.  
  118. rtype = INPROC;
  119. strcpy(pname, "recwait");
  120. pnum = 1;
  121. drec = ptr;
  122. lenr = sizeof(struct rcwait);
  123. gtf(rtype, pname, pnum, drec, lenr);
  124. /***********************************/
  125. #endif
  126.  
  127.  
  128.     if (chkparm(ptr, &ar) == -1) {
  129.        return(0);
  130.     }
  131.     ptr_rcb = ar.p_rcb;
  132.     ptr_tcb = ar.p_tcb;
  133.  
  134.     ptr -> prim_rc = OK;
  135.     ptr -> sec_rc = OK;
  136.  
  137.     /*   ó  RCB  ºá¡«ß¿¼ ¬«ñ »α¿¼¿Γ¿óá  */
  138.     ptr_rcb ->verb_code = ptr -> code;
  139.     ptr_rcb -> verb_ptr = ptr;
  140.  
  141.     part = ptr_rcb -> p_partner;
  142.     state = 0;
  143.  
  144.     if (part -> lu_type != 0) {
  145.         if((state = fsm_conv('s',Receive_and_wait,ptr_rcb)) == -1) {
  146.            ptr -> prim_rc = PORT_ABENDED;
  147.            return (0);
  148.         }
  149.     }
  150.  
  151.     if(state == 1) {
  152.        ptr -> prim_rc = PORT_ABENDED;
  153.        return (0);
  154.     }
  155.     else
  156.     {
  157.             switch (ptr_rcb->error_state)    {
  158.                case CONV_FAILURE_PROTOCOL_ERROR:
  159.                    {
  160.                       fsm_conv('r',RESOURCE_FAILURE_RC,ptr_rcb);
  161.                       setrc(ptr, ptr_rcb);
  162.                       break;
  163.                    }
  164.                case CONV_FAILURE_SON:
  165.                    {
  166.                       ptr->prim_rc = RESOURCE_FAILURE_RETRY;
  167.                       fsm_conv('r',RESOURCE_FAILURE_RC,ptr_rcb);
  168.                       break;
  169.                    }
  170.                case ALLOCATION_FAILURE_RETRY:
  171.                case ALLOCATION_FAILURE_NO_RETRY:
  172.                case SYNC_LEVEL_NOT_SUPPORTED:
  173.                    {
  174.                       ptr->prim_rc = ALLOCATION_ERROR;
  175.                       if(ptr_rcb->error_state == ALLOCATION_FAILURE_RETRY)
  176.                       ptr->sec_rc = ALLOCATION_FAILURE_RETRY;
  177.                       if(ptr_rcb->error_state == ALLOCATION_FAILURE_NO_RETRY)
  178.                            {
  179.                                ptr->sec_rc = ALLOCATION_FAILURE_NO_RETRY;
  180.                            }
  181.                       else
  182.                            {
  183.                                ptr->sec_rc = SYNC_LEVEL_NOT_SUPPORTED_BY_LU;
  184.                            }
  185.                       fsm_conv('r',ALLOCATION_ERROR_RC,ptr_rcb);
  186.                       break;
  187.                    }
  188.            case RCVD_ERROR:
  189.                    {
  190.                       if(ptr_rcb->conv_state == SEND) {
  191.                            p = &((*ptr_rcb).first_out);
  192.                            type = Prepare_to_receive;
  193.                            buffmng('A', NULL, p, ptr_rcb, 0, 0, type);
  194.                            sendhsf(ptr_rcb);
  195.                       }
  196.                       if ((ptr_rcb->error_state == CONV_FAILURE_SON)||
  197.                           (ptr_rcb->error_state == CONV_FAILURE_PROTOCOL_ERROR))
  198.                            {
  199.                               if (ptr_rcb->error_state == CONV_FAILURE_SON)
  200.                                    {
  201.                                       ptr->prim_rc = RESOURCE_FAILURE_RETRY;
  202.                                    }
  203.                               else
  204.                                    {
  205.                                       ptr->prim_rc = RESOURCE_FAILURE_NO_RETRY;
  206.                                    }
  207.                               fsm_conv('r',RESOURCE_FAILURE_RC,ptr_rcb);
  208.                            }
  209.                       break;
  210.                    }
  211.            case NO_RQS:
  212.                    {
  213.                             p_rep = ptr;
  214.                             if (ptr_rcb -> hsps != YES) {
  215.                                 if (ptr -> code == Receive_immediate) {
  216.                                     ptr -> prim_rc = UNSUCCESSFUL;
  217.                                     return (0);
  218.                                 }
  219.                                 p_rep -> complete = 1; /* req. to retry */
  220.                                 p_rep -> p_rcb = ptr_rcb;
  221.                                 return (0);
  222.                             }
  223.                             p_rep -> complete = 0; /* req. will be complete */
  224.                             p_rep -> tp_fd = ptr_tcb -> tp_fd;
  225.  
  226.                          /* perform_receive_processing */
  227.                             if ((cnt = ptr -> maxlen) <= 0) {
  228.                                  cnt = MAX_RU;
  229.                             }
  230. #if OS_TYPE == 1 /* Unix System V */
  231.                             if ((p = malloc(cnt)) == NULL) {
  232.                                 ptr -> prim_rc = PORT_BUSY;
  233.                                 return (0);
  234.                             }
  235.                             ptr -> data_addr = p;
  236. #endif
  237. #if OS_TYPE == 0 /* MS-DOS */
  238.                             p = ptr -> data_addr;
  239. #endif
  240.                             switch (rcvhs(&cnt, ptr_rcb, &type, p)) {
  241.                                 case 0 :
  242.                                          {
  243.                                             ptr -> data_lt = cnt;
  244.                                             if (type == Request_to_send) {
  245.                                             ptr_rcb -> rq_to_send_rcvd = YES;
  246.                                             }
  247.                                             else
  248.                                                    ptr_rcb->rq_to_send_rcvd = No;
  249.                                             switch (type) {
  250.                                                 case DATA :
  251.                                                             {
  252.                                                                 ptr -> what_received = Data_INCOMPLETE;
  253.                                                                 break;
  254.                                                             }
  255.                                                 case Confirm :
  256.                                                             {
  257.                                                                 ptr -> what_received = ConfirM;
  258.                                                                 break;
  259.                                                             }
  260.                                                 case Send_data :
  261.                                                             {
  262.                                                                 ptr -> what_received = Data_COMPLETE;
  263.                                                                 break;
  264.                                                             }
  265.                                                 case SenD :
  266.                                                 case PREP_TO_RCV_FLUSH      :
  267.                                                             {
  268.                                                                 ptr -> what_received = SenD;
  269.                                                                 if (fsm_conv('R', send_indicator, ptr_rcb) != 0) {
  270.                                                                     ptr -> prim_rc = PORT_ABENDED;
  271.                                                                     return (0);
  272.                                                                 }
  273.                                                                 break;
  274.                                                             }
  275.                                                 case Deallocate_confirm :
  276.                                                             {
  277.                                                                 if (fsm_conv('R', confirm_dealloc_ind, ptr_rcb) != 0) {
  278.                                                                     ptr -> prim_rc = PORT_ABENDED;
  279.                                                                     return (0);
  280.                                                                 }
  281.  
  282.                                                                 ptr -> what_received = Confirm_DEALLOCATE;
  283.                                                                 break;
  284.                                                             }
  285.                                                 case Deallocate_flush :
  286.                                                             {
  287.                                                                 if (fsm_conv('R', Dealloc_normal_rc, ptr_rcb) != 0) {
  288.                                                                     ptr -> prim_rc = PORT_ABENDED;
  289.                                                                     return (0);
  290.                                                                 }
  291.                                                                 ptr -> prim_rc = deallocate_normal;
  292.                                                                 del_rcb.p_tcb = ptr_tcb;
  293.                                                                 del_rcb.p_rcb = ptr_rcb;
  294.                                                                 psrm(DEALLOCATE_RCB, &del_rcb, 0);
  295.                                                                 break;
  296.                                                             }
  297.                                                 case PREP_TO_RCV_CONFIRM_SH:
  298.                                                 case PREP_TO_RCV_CONFIRM_LG:
  299.                                                             {
  300.                                                                 ptr -> what_received = Confirm_SEND;
  301.                                                                 break;
  302.                                                             }
  303.                                                 default :
  304.                                                             {
  305.                                                                 ptr -> what_received = type;
  306.                                                             }
  307.                                              }
  308.                                             goto End;
  309.                                           }
  310.                                 case 1 :
  311.                                          {
  312.                                             ptr -> prim_rc = CONV_FAILURE_RETRY;
  313.                                             break;
  314.                                          }
  315.                                 case 2 :
  316.                                          {
  317.                                             p1 = service_error_rc;
  318.                                             fsm_conv('R', p1, ptr_rcb);
  319.                                             ptr -> prim_rc = PORT_BUSY;
  320.                                             return (0);
  321.                                          }
  322.                              }
  323.                              if ((p = realloc(p, cnt)) == NULL) {
  324.                                 ptr -> prim_rc = UNSUCCESSFUL;
  325.                              }
  326.                    }
  327.             }
  328.     }
  329.     End:
  330.          if ( ptr_rcb->rq_to_send_rcvd == YES ) {
  331.                 ptr->rts = YES;
  332.                 ptr_rcb->rq_to_send_rcvd = No;
  333.          }
  334. }
  335.